{***************************************************************
    SpyGestion  Copyright (C) 2008 Christophe KOALI <nature2gas@gmail.com>
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
    
****************************************************************}
unit modProfilsForAttack;

interface

uses Classes, IniFiles, SysUtils;


const
    LANG_INTERNAL = '';

    CNT_FILTRE_LNE_STATE_EXCLURE        = 0;
    CNT_FILTRE_LNE_STATE_INCLURE        = 1;
    CNT_FILTRE_LNE_STATE_LUNE_SEULEMENT = 2;


type


   TProfilsAttack = class(TObject)
   private
      // fichier de sauvegarde
      FFichier: string;

      
      // pseudo du joueur
      FPseudo : string;
      FPassword : string;

      // univers
      FUnivers: integer;
      FLangUni: string;
      FDirectLogin: boolean;
      FDirectLoginURL: string;

      // Proxy
      FProxyHostname: string;
      FProxyPort    : integer;
      FProxyType    : integer;
      FProxyActive  : boolean;

      FProxyUsername: string;
      FProxyPassword: string;
      FProxyIdentifActive: boolean;





      FAgent : string;
      FAcceptLanguage: string;
      FAccept: string;
      FGZipEncoding: boolean;

      // Limites de points
      FLimitStatsGlobal : integer;
      FLimitStatsFlotte : integer;


      // Limite de defense pour la coloration
      FLimitQtDefense: integer;
      FLimitQtFlotte : integer;

      // Limites de points pour le sondage
      FSondageLimitStatsGlobal: integer;
      FSondageLimitStatsGlobalInclureNonClasse: boolean;

      FSondageLimitStatsFlottes: integer;
      FSondageLimitStatsFlottesInclureNonClasse: boolean;

      // Autre informations pour le sondage
      FSondageSystemRangeStart: integer;
      FSondageSystemRangeEnd: integer;
      FSondageLastPlaneteSel : integer;  // l'index dans la combobox
      FAttackLastPlaneteSel: integer; // index dans la combobox

      // Durée utilisée sur la date du dernier scan du système solaire, si trop vieux alors la planète sera ignorée
      FSondageDureeToBeConsideredAsRecent: integer;  // ce n'est qu'une durée, int64 est inutile

      // Durée utilisée sur la date du dernier sondage de la planète, si trop récent, alors la planète sera non sondée
      FSondageDureeToDontBeSondeANouveau: integer;



      FSondesNbMini: integer;
      FSondesNbNivEsp: integer;



      // Pour définir le flag "Peu Dev" de manière automatique
      FNewbzLevelMineMetal  : integer;
      FNewbzLevelMineCristal: integer;
      FNewbzLevelMineBoth   : integer;
      FNewbzDelaisIngoreSondage : integer;
      FNewbzSetFlagPeuDevAuto   : integer;


      // Définit si on affiche les ressources sous forme de GT ou de PT
      FVersionPT  : boolean;




      // Fichier base de donnes par galaxie
      // L'indice 0 correspond a la galaxie 1
      FFichierRapportDB: TStringList;

      // alliances alliees
      FAlliancesAlliees : TStringList;

      FLastRapportGalaxieUsed: integer;


      // Planète au format "Nom - Coord" (celui utilisé dans les combobox et menus)
      // Pour pouvoir les recharger sans avoir à faire de login
      FPlanetesList: TStringList;

      procedure LoadAllianceFromLigne(Key, Value: string);
      procedure LoadGeneralLigne(Key, Value: string);
      procedure LoadGalaxiesFromLigne(Key, Value: string);
      procedure LoadPlaneteFromLigne(Key, Value: string);
      procedure LoadSondageLigne(Key, Value: string);
      procedure LoadProxyLigne(Key, Value: string);
      procedure LoadAlerteAttaqueLigne(Key, Value: string);
      procedure LoadEvacuationLigne(Key, Value: string);


   public
      GrilleDesactiveColonneDef: boolean;


      // Pour les éléments filtrée (et sauvegardé le filtre)
      FiltrePresenceTousDefaut : boolean;
      FiltreFlagsAucunRapportInclu: boolean;  // si False, alors Exclu (il n'y a pas de 'sans importance')
      FiltreFlagsRapportInclu  : longword;

      // Une planète peut avoir plusieurs flags, on peut exclure (interdire) des flags
      // même si la planète correspond à d'autre flag "inclu"
      FiltreFlagsRapportExclu  : longword;

      FiltreFlagsGalaxieInclu: longword;
      FiltreFlagsGalaxieExclu: longword;

      // toute vérifie, sinon au moins une
      FiltreInclusionMethodAllVerif: boolean;

      FiltreLuneState: integer;

      
      ///////////////////////////
      // Alerte d'attaque

      // beep
      AlerteAttBeepActive: boolean;
      AlerteAttBeepQuantite: integer;
      AlerteAttBeepIntervalle: integer;
      AlerteAttBeepUntilImpact: boolean;

      AlerteAttBeepFreq: integer;
      AlerteAttBeepDuree: integer;


      // musique
      AlerteAttMusiqueActive: boolean;
      AlerteAttMusiqueQuantite: integer;
      AlerteAttMusiqueIntervalle: integer;
      AlerteAttMusiqueUntilImpact: boolean;
      AlerteAttMusiqueFichier: string;

      // programme externe
      AlerteAttProgExtActive    : boolean;
      AlerteAttProgExtFichier   : string;
      AlerteAttProgExtParametres: string;


      // fréquence de vérification d'attaque
      AlerteAttVerifEveryMinutes: integer;
      AlerteAttVerifHumanAdd    : integer;

      // intervalle de vérification (en minutes)
      AlerteAttVerifEveryMinutesWhenAttacked: integer;
      AlerteAttVerifHumanAddWhenAttacked    : integer;

      // configuration
      AlerteAttEnableOnLogin    : boolean;


      //
      ////////////////////////////////////////////////////


      // Auto relogin

      // Active l'auto relogin
      AutoReloginEnable   : boolean;

      // délai d'attente pour se relogger lorsque l'on détecte l'expiration de session
      AutoReloginDelay           : integer;
      AutoReloginDelayAjoutRandom: integer;

      // intervalle minimal entre chaque auto relogin
      AutoReloginMinInterval: integer;



      MessageListSauvegardeRapportDeCombat: boolean;


      //
      // Evacuation de flotte
      //

      EvacuationActive: boolean;
      EvacuationSeulementSiOnPerdLaBataille: boolean;

      // On evacue la flotte X secondes avant l'impact
      EvacuationDeFlotteDelaiAvantImpact : integer;
      EvacuationDeFlotteDelaiAvantImpactRandom: integer;

        // Combien de temps après l'évacuation on fait revenir la flotte ?
        // Mettre à 0 pour desactiver
        EvacuationDeFlotteRetourDelaiEnable: boolean;
        EvacuationDeFlotteRetourDelai      : integer;
        EvacuationDeFlotteRetourDelaiRandom: integer;


      // la défense sera multipliée par ce nombre (divisé par 100)
      EvacuationPourcentagePropreFlotte  : integer;
      EvacuationPourcentablePropreDefense: integer;



      CapaciteFretCalculMethodUseContrainte: boolean;


      HumanGalaxieScanEnable   : boolean;
      HumanGalaxieScanDuree    : integer;
      HumanGalaxieScanAleatoire: integer;



      //
      // Specialite des univers
      //

      // defense recyclable
      UniversDefenseRecyclable: boolean;
      UniversDefenseRecyclPourcent: integer; // 30% normalement

      // il me semble que la vitesse est changé pour les deux éléments:
      UniversSpeedFactorElements: integer;
      UniversSpeedFactorFlotte  : integer;

      UniversNbGalaxy: integer;
      UniversNbSystemSolaireParGalaxy: integer;


      //
      // OGS
      //

      OGSServeurURL: string;
      OGSUsername  : string;
      OGSPassword  : string;
      OGSExportQuantityCartographie: integer;
      OGSExportQuantityRapports    : integer;
      OGSExportDuration            : integer;



      property Pseudo  : string read FPseudo write FPseudo;
      property Password: string read FPassword write FPassword;

      property Univers : integer read FUnivers write FUnivers;
      property LangageUni: string read FLangUni write FLangUni;


      property ProxyHostname : string  read FProxyHostname write FProxyHostname;
      property ProxyPort     : integer read FProxyPort     write FProxyPort;
      property ProxyType    : integer  read FProxyType       write FProxyType;
      property ProxyActive  : boolean  read FProxyActive     write FProxyActive;

      property ProxyUsername: string   read FProxyUsername   write FProxyUsername;
      property ProxyPassword: string   read FProxyPassword   write FProxyPassword;
      property ProxyIdentActive: boolean   read FProxyIdentifActive   write FProxyIdentifActive;



//      FProxyIdentifActive: boolean;



      property NavAgent         : string  read FAgent         write FAgent;
      property NavAcceptLanguage : string  read FAcceptLanguage   write FAcceptLanguage;
      property NavAccept         : string  read FAccept           write FAccept;
      property NavGZipEncoding   : boolean  read FGZipEncoding           write FGZipEncoding;





      property LastGalaxieUsed: integer read FLastRapportGalaxieUsed write FLastRapportGalaxieUsed;


      property LimitStGlobal: integer read FLimitStatsGlobal write FLimitStatsGlobal;
      property LimitStFlotte: integer read FLimitStatsFlotte write FLimitStatsFlotte;

      property LimitQtDefense: integer read FLimitQtDefense write FLimitQtDefense;
      property LimitQtFlottes: integer read FLimitQtFlotte write FLimitQtFlotte;

      property AlliancesAlliees: TStringList read FAlliancesAlliees;
      property PlanetesList    : TStringList read FPlanetesList;



      property VersionPT : boolean read FVersionPT write FVersionPT;



      property SondesNbMini  : integer read FSondesNbMini    write FSondesNbMini;
      property SondesNbNivEsp: integer read FSondesNbNivEsp  write FSondesNbNivEsp;






      property SondageLimitStatsGlobal: integer read FSondageLimitStatsGlobal write FSondageLimitStatsGlobal;
      property SondageLimitStatsGlobalInclureNonClasse: boolean read FSondageLimitStatsGlobalInclureNonClasse write FSondageLimitStatsGlobalInclureNonClasse;
      property SondageLimitStatsFlottes: integer read FSondageLimitStatsFlottes write FSondageLimitStatsFlottes;
      property SondageLimitStatsFlottesInclureNonClasse: boolean read FSondageLimitStatsFlottesInclureNonClasse write FSondageLimitStatsFlottesInclureNonClasse;

      property SondageSystemRangeStart    : integer read FSondageSystemRangeStart write FSondageSystemRangeStart;
      property SondageSystemRangeEnd      : integer read FSondageSystemRangeEnd   write FSondageSystemRangeEnd;
      property SondageLastPlaneteSel      : integer read FSondageLastPlaneteSel   write FSondageLastPlaneteSel;
      property AttackLastPlanete          : integer read FAttackLastPlaneteSel    write FAttackLastPlaneteSel;


      property SondageDureeToBeConsideredAsRecent: integer read FSondageDureeToBeConsideredAsRecent write FSondageDureeToBeConsideredAsRecent;

      property SondageDureeToDontBeSondeANouveau: integer read FSondageDureeToDontBeSondeANouveau write FSondageDureeToDontBeSondeANouveau;


      property NewbzLevelMineMetal     : integer read FNewbzLevelMineMetal      write FNewbzLevelMineMetal;
      property NewbzLevelMineCristal   : integer read FNewbzLevelMineCristal    write FNewbzLevelMineCristal;
      property NewbzLevelMineBoth      : integer read FNewbzLevelMineBoth       write FNewbzLevelMineBoth;
      property NewbzDelaisIngoreSondage: integer read FNewbzDelaisIngoreSondage write FNewbzDelaisIngoreSondage;
      property NewbzSetFlagPeuDevAuto  : integer read FNewbzSetFlagPeuDevAuto   write FNewbzSetFlagPeuDevAuto;


      
      // Renvoi le fichier base de donnees pour cette galaxie
      function GetRapportDB(Galaxie: integer): string;
      procedure SetRapportDB(Galaxie: integer; Fichier: string);
      procedure SetLastUsedRapportDB(Galaxie: integer);

      function IsAllianceAlliees(Alliance: string): boolean;
      function IsPlayerAllies(Joueur: string): boolean;


      function SaveToFile(Fichier: string): integer;
      function LoadFromFile(Fichier: string): integer;

      function IsValidProfil: boolean;

      procedure InitProfil;
      procedure SetDefaultValue;


      constructor Create;
      destructor Destroy; override;
   end;


implementation

const
   CNT_SECTION_ALERTE_ATTAQUE = 'alerte_att';

      // beep
      CNT_SAVE_AlerteAttBeepActive       = 'BeepActive';
      CNT_SAVE_AlerteAttBeepQuantite     = 'BeepQuantite';
      CNT_SAVE_AlerteAttBeepIntervalle   = 'BeepIntervalle';
      CNT_SAVE_AlerteAttBeepUntilImpact  = 'BeepUntilImpact';

      CNT_SAVE_AlerteAttBeepFreq     = 'BeepFreq';
      CNT_SAVE_AlerteAttBeepDuree    = 'BeepDuree';


      // musique
      CNT_SAVE_AlerteAttMusiqueActive       = 'MusiqueActive';
      CNT_SAVE_AlerteAttMusiqueQuantite     = 'MusiqueQuantite';
      CNT_SAVE_AlerteAttMusiqueIntervalle   = 'MusiqueIntervalle';
      CNT_SAVE_AlerteAttMusiqueUntilImpact  = 'MusiqueUntilImpact';
      CNT_SAVE_AlerteAttMusiqueFichier      = 'MusiqueFichier';

      // programme externe
      CNT_SAVE_AlerteAttProgExtActive        = 'ProgExtActive';
      CNT_SAVE_AlerteAttProgExtFichier       = 'ProgExtFichier';
      CNT_SAVE_AlerteAttProgExtParametres    = 'ProgExtParametres';


      // fréquence de vérification d'attaque
      CNT_SAVE_AlerteAttVerifEveryMinutes  = 'VerifEveryMinutes';
      CNT_SAVE_AlerteAttVerifHumanAdd      = 'VerifHumanAdd';


      CNT_SAVE_AlerteAttVerifEveryMinutesWhenAttacked  = 'VerifEveryMinutesWhenAttacked';
      CNT_SAVE_AlerteAttVerifHumanAddWhenAttacked      = 'VerifHumanAddWhenAttacked';


      // configuration
      CNT_SAVE_AlerteAttEnableOnLogin      = 'EnableOnLogin';





      // defense recyclable
      CNT_SAVE_UniversDefenseRecyclable      = 'uDefenseRecyclable';
      CNT_SAVE_UniversDefenseRecyclPourcent  = 'uDefenseRecyclPourcent'; // 30% normalement

      // il me semble que la vitesse est changé pour les deux éléments:
      CNT_SAVE_UniversSpeedFactorElements = 'uSpeedFactorElements';
      CNT_SAVE_UniversSpeedFactorFlotte   = 'uSpeedFactorFlotte';

      CNT_SAVE_UniversNbGalaxy = 'uNbGalaxy';
      CNT_SAVE_UniversNbSystemSolaireParGalaxy = 'uNbSystemSolaireParGalaxy';


      CNT_SAVE_OGSServeurURL = 'OGSServeurURL';
      CNT_SAVE_OGSUsername   = 'OGSUsername';
      CNT_SAVE_OGSPassword   = 'OGSPassword';
      CNT_SAVE_OGSExportQuantityCartographie  = 'OGSExpQtCt';
      CNT_SAVE_OGSExportQuantityRapports      = 'OGSExpQtRp';
      CNT_SAVE_OGSExportDuration              = 'OGSDuration';






      //
      // Auto relogin
      //

      // Active l'auto relogin
      CNT_SAVE_AutoReloginEnable   = 'AutoReloginEnable';

      // délai d'attente pour se relogger lorsque l'on détecte l'expiration de session
      CNT_SAVE_AutoReloginDelay    = 'AutoReloginDelay';

      // intervalle minimal entre chaque auto relogin
      CNT_SAVE_AutoReloginMinInterval= 'AutoReloginMinInterval';


      CNT_SAVE_CapaciteFretCalculMethodUseContrainte = 'FretCalculMethod';

   CNT_SAVE_PSEUDO = 'nick';
   CNT_SAVE_FPassword = 'Password';

   CNT_SAVE_FUnivers = 'Univers';
   CNT_SAVE_FLangUni = 'UniversLang';

   CNT_SAVE_FLimitGlobal = 'LimitStGlobal';
   CNT_SAVE_FLimitFlotte = 'LimitStFlotte';

   CNT_SAVE_FLimitQtDefense = 'LimitQtDefense';
   CNT_SAVE_FLimitQtFlotte = 'LimitQtFlotte';

   CNT_SAVE_LastGalaxieLoaded = 'LastGalaxieUsed';

   CNT_SAVE_MessageListSauvegardeRapportDeCombat = 'MsgListSaveRC';




   CNT_SAVE_EvacuationActive = 'EvaActive';
   CNT_SAVE_EvacuationSeulementSiOnPerdLaBataille = 'SeulementSiOnPerdLaBataille';


      // On evacue la flotte X secondes avant l'impact

      CNT_SAVE_EvacuationDeFlotteDelaiAvantImpact       = 'DelaiAvantImpact';
      CNT_SAVE_EvacuationDeFlotteDelaiAvantImpactRandom = 'DelaiAvantImpactRandom';

        // Combien de temps après l'évacuation on fait revenir la flotte ?
        // Mettre à 0 pour desactiver
        CNT_SAVE_EvacuationDeFlotteRetourDelaiEnable = 'RetourDelaiEnable';
        CNT_SAVE_EvacuationDeFlotteRetourDelai       = 'RetourDelai';
        CNT_SAVE_EvacuationDeFlotteRetourDelaiRandom = 'RetourDelaiRandom';

      CNT_SAVE_EvacuationPourcentagePropreFlotte   = 'PourcentagePropreFlotte';
      CNT_SAVE_EvacuationPourcentablePropreDefense = 'PourcentablePropreDefense';



   CNT_SECTION_PRINCIPALE = 'general';
   CNT_SECTION_ALLIANCES = 'alliances';
   CNT_SECTION_GALAXIESDB = 'galaxies';
   CNT_SECTION_PLANETES  = 'planetes';
   CNT_SECTION_SONDAGE  = 'sondage';
   CNT_SECTION_EVACUATION  = 'evacuation';


   CNT_SAVE_FAgent         = 'Agent';
   CNT_SAVE_FAcceptLanguage = 'NavAcceptLanguage';
   CNT_SAVE_FAccept        = 'NavAccept';
   CNT_SAVE_FGZipEncoding        = 'GZipEncoding';




   CNT_SAVE_FSondageLimitStatsGlobal = 'LimitStatsGlobal';
   CNT_SAVE_FSondageLimitStatsGlobalInclureNonClasse = 'LimitStatsGlobalInclureNonClasse';
   CNT_SAVE_FSondageLimitStatsFlottes = 'LimitStatsFlottes';
   CNT_SAVE_FSondageLimitStatsFlottesInclureNonClasse = 'LimitStatsFlottesInclureNonClasse';

   CNT_SAVE_FSondageSystemRangeStart = 'SystemRangeStart';
   CNT_SAVE_FSondageSystemRangeEnd = 'SystemRangeEnd';
   CNT_SAVE_FSondageLastPlaneteSel = 'LastPlaneteSel';
   CNT_SAVE_FAttackLastPlanete = 'AttackLastPlanete';




   CNT_SAVE_FSondageDureeToBeConsideredAsRecent = 'DureeToBeConsideredAsRecent';

   CNT_SAVE_FSondageDureeToDontBeSondeANouveau = 'DureeToDontBeSondeANouveau';


   CNT_SAVE_FVersionPT                = 'VersionPT';


   CNT_SECTION_PROXY = 'proxy';

      CNT_SAVE_FProxyHostname = 'hostname';
      CNT_SAVE_FProxyPort     = 'port';
      CNT_SAVE_FProxyType     = 'type';
      CNT_SAVE_FProxyActive   = 'actif';

      CNT_SAVE_FProxyUsername = 'username';
      CNT_SAVE_FProxyPassword = 'password';
      CNT_SAVE_FProxyIdentifActive = 'identification';




      CNT_SAVE_FSondesNbMini   = 'SondesNbMini';
      CNT_SAVE_FSondesNbNivEsp = 'SondesNbNivEsp';



   CNT_SAVE_FNewbzLevelMineMetal      = 'NewbzLevelMineMetal';
   CNT_SAVE_FNewbzLevelMineCristal    = 'NewbzLevelMineCristal';
   CNT_SAVE_FNewbzLevelMineBoth       = 'NewbzLevelMineBoth';
   CNT_SAVE_FNewbzDelaisIngoreSondage = 'NewbzDelaisIngoreSondage';
   CNT_SAVE_FNewbzSetFlagPeuDevAuto   = 'NewbzSetFlagPeuDevAuto';



   CNT_SAVE_FiltrePresenceTousDefaut     = 'FiltrePresenceTousDefaut';
   CNT_SAVE_FiltreFlagsAucunRapportInclu = 'FiltreFlagsAucunRapportInclu';

   CNT_SAVE_FiltreFlagsRapportInclu      = 'FiltreFlagsRapportInclu';
   CNT_SAVE_FiltreFlagsRapportExclu   = 'FiltreFlagsRapportExclu';
   CNT_SAVE_FiltreFlagsGalaxieInclu   = 'FiltreFlagsGalaxieInclu';
   CNT_SAVE_FiltreFlagsGalaxieExclu   = 'FiltreFlagsGalaxieExclu';

   CNT_SAVE_FiltreInclusionMethodAllVerif  = 'FiltreInclusionMethodAllVerif';



      CNT_SAVE_HumanGalaxieScanEnable    = 'HumanGalaxieScanEnable';
      CNT_SAVE_HumanGalaxieScanDuree     = 'HumanGalaxieScanDuree';
      CNT_SAVE_HumanGalaxieScanAleatoire = 'HumanGalaxieScanAleatoire';





function TProfilsAttack.IsPlayerAllies(Joueur: string): boolean;
begin
    Joueur := lowercase(trim(Joueur));

    Result := false;

    if SameText(Joueur, FPseudo) then begin
       Result := true;
       exit;
    end;

end;

function TProfilsAttack.IsAllianceAlliees(Alliance: string): boolean;
var i: integer;
begin

    i := FAlliancesAlliees.IndexOf(lowercase(trim(Alliance)));

    if i < 0 then
       Result := false
    else
       Result := true;

end;


/////////////////////////////////////////////////////////////////
// Bien que sauvegarder dans SaveToFile, ici on force la sauvegarde,
// car SaveToFile n est pas tout le temps appelle, il est meme invoquer tres
// rarement
procedure TProfilsAttack.SetLastUsedRapportDB(Galaxie: integer);
var F: TIniFile;
begin

    if FFichier = '' then exit;

    FLastRapportGalaxieUsed := Galaxie;

    try
       F := TIniFile.Create(FFichier);
    except
       // erreur d ouverture
       F := nil;
    end;

    if F = nil then exit;

    F.WriteInteger(CNT_SECTION_PRINCIPALE, CNT_SAVE_LastGalaxieLoaded, FLastRapportGalaxieUsed);

    F.Free;

end;



function localBoolToInt(b: boolean): integer;
begin
   if b then
      Result := 1
   else
      Result := 0;

end;

function TProfilsAttack.SaveToFile(Fichier: string): integer;
const FORMAT_STR = '%s=%s';
      FORMAT_INT = '%s=%d';

var F: TextFile;
    i: integer;
begin

    if Fichier = '' then Fichier := FFichier;

    if Fichier = '' then begin
       Result := -2;
       exit;
    end;
    
    AssignFile(F, Fichier);

    {$I-}
       ReWrite(F);
    {$I+}

    // IOResult renvoie 0 => cela signifie que la dernière opération d'E/S a réussi
    if NoT(IOResult = 0) then begin
       Result := -1;
       exit;
    end;

    WriteLn(F, '[' + CNT_SECTION_PRINCIPALE + ']');

    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_PSEUDO, FPseudo]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_FPassword, FPassword]));

    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_FAgent, FAgent]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_FAcceptLanguage, FAcceptLanguage]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_FAccept, FAccept]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FGZipEncoding, localBoolToInt(FGZipEncoding)]));


    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_MessageListSauvegardeRapportDeCombat, localBoolToInt(MessageListSauvegardeRapportDeCombat)]));



    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_CapaciteFretCalculMethodUseContrainte, localBoolToInt(CapaciteFretCalculMethodUseContrainte)]));




    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FUnivers, FUnivers]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_FLangUni, FLangUni]));




    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_HumanGalaxieScanEnable, localBoolToInt(HumanGalaxieScanEnable)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_HumanGalaxieScanDuree, HumanGalaxieScanDuree]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_HumanGalaxieScanAleatoire, HumanGalaxieScanAleatoire]));





    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FLimitGlobal, FLimitStatsGlobal]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FLimitFlotte, FLimitStatsFlotte]));

    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FLimitQtDefense, FLimitQtDefense]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FLimitQtFlotte, FLimitQtFlotte]));

    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_LastGalaxieLoaded, FLastRapportGalaxieUsed]));

    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FNewbzLevelMineMetal     , FNewbzLevelMineMetal]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FNewbzLevelMineCristal   , FNewbzLevelMineCristal]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FNewbzLevelMineBoth      , FNewbzLevelMineBoth]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FNewbzDelaisIngoreSondage, FNewbzDelaisIngoreSondage]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FNewbzSetFlagPeuDevAuto  , FNewbzSetFlagPeuDevAuto]));

    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FVersionPT     , localBoolToInt(FVersionPT)]));



    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondesNbMini    , FSondesNbMini]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondesNbNivEsp  , FSondesNbNivEsp]));




    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AutoReloginEnable, localBoolToInt(AutoReloginEnable)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AutoReloginDelay  , AutoReloginDelay]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AutoReloginMinInterval  , AutoReloginMinInterval]));



    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FiltrePresenceTousDefaut     , localBoolToInt(FiltrePresenceTousDefaut)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FiltreFlagsAucunRapportInclu , localBoolToInt(FiltreFlagsAucunRapportInclu)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FiltreFlagsRapportInclu      , FiltreFlagsRapportInclu]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FiltreFlagsRapportExclu      , FiltreFlagsRapportExclu]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FiltreFlagsGalaxieInclu      , FiltreFlagsGalaxieInclu]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FiltreFlagsGalaxieExclu      , FiltreFlagsGalaxieExclu]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FiltreInclusionMethodAllVerif, localBoolToInt(FiltreInclusionMethodAllVerif)]));



    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_UniversDefenseRecyclable, localBoolToInt(UniversDefenseRecyclable)]));

    WriteLn(F, format(FORMAT_INT , [CNT_SAVE_UniversDefenseRecyclPourcent      , UniversDefenseRecyclPourcent]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_UniversSpeedFactorElements      , UniversSpeedFactorElements]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_UniversSpeedFactorFlotte      , UniversSpeedFactorFlotte]));

    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_UniversNbGalaxy      , UniversNbGalaxy]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_UniversNbSystemSolaireParGalaxy      , UniversNbSystemSolaireParGalaxy]));




    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_OGSServeurURL, OGSServeurURL]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_OGSUsername  , OGSUsername]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_OGSPassword  , OGSPassword]));

    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_OGSExportQuantityCartographie , OGSExportQuantityCartographie]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_OGSExportQuantityRapports     , OGSExportQuantityRapports]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_OGSExportDuration             , OGSExportDuration]));



    // Evacuation
    WriteLn(F, '');
    WriteLn(F, '[' + CNT_SECTION_EVACUATION + ']');


    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_EvacuationActive, localBoolToInt(EvacuationActive)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_EvacuationSeulementSiOnPerdLaBataille, localBoolToInt(EvacuationSeulementSiOnPerdLaBataille)]));


    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_EvacuationPourcentagePropreFlotte, EvacuationPourcentagePropreFlotte]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_EvacuationPourcentablePropreDefense, EvacuationPourcentablePropreDefense]));


    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_EvacuationDeFlotteDelaiAvantImpact, EvacuationDeFlotteDelaiAvantImpact]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_EvacuationDeFlotteDelaiAvantImpactRandom, EvacuationDeFlotteDelaiAvantImpactRandom ]));


    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_EvacuationDeFlotteRetourDelaiEnable, localBoolToInt(EvacuationDeFlotteRetourDelaiEnable)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_EvacuationDeFlotteRetourDelai, EvacuationDeFlotteRetourDelai]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_EvacuationDeFlotteRetourDelaiRandom, EvacuationDeFlotteRetourDelaiRandom ]));




    // proxy

    WriteLn(F, '');
    WriteLn(F, '[' + CNT_SECTION_PROXY + ']');

    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_FProxyHostname, FProxyHostname]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FProxyPort, FProxyPort]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_FProxyUsername, FProxyUsername]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_FProxyPassword, FProxyPassword]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FProxyType    , FProxyType]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FProxyActive     , localBoolToInt(FProxyActive)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FProxyIdentifActive, localBoolToInt(FProxyIdentifActive)]));





    WriteLn(F, '');
    WriteLn(F, '[' + CNT_SECTION_ALERTE_ATTAQUE + ']');

    // beep
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttBeepActive     , localBoolToInt(AlerteAttBeepActive)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttBeepQuantite   , AlerteAttBeepQuantite]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttBeepIntervalle , AlerteAttBeepIntervalle]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttBeepUntilImpact, localBoolToInt(AlerteAttBeepUntilImpact)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttBeepFreq       , AlerteAttBeepFreq]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttBeepDuree      , AlerteAttBeepDuree]));



    // musique
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttMusiqueActive      , localBoolToInt(AlerteAttMusiqueActive)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttMusiqueQuantite    , AlerteAttMusiqueQuantite]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttMusiqueIntervalle  , AlerteAttMusiqueIntervalle]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttMusiqueUntilImpact , localBoolToInt(AlerteAttMusiqueUntilImpact)]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_AlerteAttMusiqueFichier     , AlerteAttMusiqueFichier]));



    // programme externe
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttProgExtActive      , localBoolToInt(AlerteAttProgExtActive)]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_AlerteAttProgExtFichier     , AlerteAttProgExtFichier]));
    WriteLn(F, format(FORMAT_STR, [CNT_SAVE_AlerteAttProgExtParametres  , AlerteAttProgExtParametres]));



    
    // fréquence de vérification d'attaque
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttVerifEveryMinutes  , AlerteAttVerifEveryMinutes]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttVerifHumanAdd      , AlerteAttVerifHumanAdd]));

    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttVerifEveryMinutesWhenAttacked  , AlerteAttVerifEveryMinutesWhenAttacked ]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttVerifHumanAddWhenAttacked      , AlerteAttVerifHumanAddWhenAttacked]));



    // configuration
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_AlerteAttEnableOnLogin      , localBoolToInt(AlerteAttEnableOnLogin)]));





    


    WriteLn(F, '');
    WriteLn(F, '[' + CNT_SECTION_SONDAGE + ']');
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondageLimitStatsGlobal, FSondageLimitStatsGlobal]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondageLimitStatsGlobalInclureNonClasse, localBoolToInt(FSondageLimitStatsGlobalInclureNonClasse)]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondageLimitStatsFlottes, FSondageLimitStatsFlottes]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondageLimitStatsFlottesInclureNonClasse, localBoolToInt(FSondageLimitStatsFlottesInclureNonClasse)]));


    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondageSystemRangeStart, FSondageSystemRangeStart]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondageSystemRangeEnd, FSondageSystemRangeEnd]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondageLastPlaneteSel, FSondageLastPlaneteSel]));
    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FAttackLastPlanete, FAttackLastPlaneteSel]));


    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondageDureeToBeConsideredAsRecent, FSondageDureeToBeConsideredAsRecent]));

    WriteLn(F, format(FORMAT_INT, [CNT_SAVE_FSondageDureeToDontBeSondeANouveau, FSondageDureeToDontBeSondeANouveau]));





    if FPlanetesList.Count > 0 then begin
       WriteLn(F, '');
       WriteLn(F, '[' + CNT_SECTION_PLANETES + ']');

       for i := 0 to FPlanetesList.Count - 1 do begin
           WriteLn(F, format('p=%s', [FPlanetesList.Strings[i]]));
       end;


    end;


    if FAlliancesAlliees.Count > 0 then begin
       WriteLn(F, '');
       WriteLn(F, '[' + CNT_SECTION_ALLIANCES + ']');

       for i := 0 to FAlliancesAlliees.Count - 1 do begin
           WriteLn(F, format('a=%s', [FAlliancesAlliees.Strings[i]]));
       end;

    end;




    if FFichierRapportDB.Count > 0 then begin
       WriteLn(F, '');
       WriteLn(F, '[' + CNT_SECTION_GALAXIESDB + ']');


       for i := 0 to FFichierRapportDB.Count - 1 do begin
           WriteLn(F, format('g%d=%s', [i + 1, FFichierRapportDB.Strings[i]]));
       end;

    end;



    WriteLn(F, '');


    // Résultat
    Result := 1;

    // Ferme le fichier
    CloseFile(F);


end;


function TProfilsAttack.IsValidProfil: boolean;
begin

    Result := true;
    
    if (FLimitStatsFlotte < 0) or (FLimitStatsGlobal < 0) or (FUnivers < 0)  or (FPseudo = '') then begin
       Result := false;
       exit;
    end;


    if (FLimitQtFlotte < 0) or (FLimitQtDefense < 0) or (FUnivers < 0)  or (FPseudo = '') then begin
       Result := false;
       exit;
    end;

end;

procedure TProfilsAttack.LoadSondageLigne(Key, Value: string);
begin

    if SameText(Key, CNT_SAVE_FSondageLimitStatsGlobal) then begin
       FSondageLimitStatsGlobal := StrToIntDef(Value, 1000);

    end else if SameText(Key, CNT_SAVE_FSondageLimitStatsGlobalInclureNonClasse) then begin
       FSondageLimitStatsGlobalInclureNonClasse := Value = '1';

    end else if SameText(Key, CNT_SAVE_FSondageLimitStatsFlottes) then begin
       FSondageLimitStatsFlottes := StrToIntDef(Value, 1000);

    end else if SameText(Key, CNT_SAVE_FSondageLimitStatsFlottesInclureNonClasse) then begin
       FSondageLimitStatsFlottesInclureNonClasse := Value = '1';


    end else if SameText(Key, CNT_SAVE_FSondageSystemRangeStart) then begin
       FSondageSystemRangeStart := StrToIntDef(Value, 1);

    end else if SameText(Key, CNT_SAVE_FSondageSystemRangeEnd) then begin
       FSondageSystemRangeEnd := StrToIntDef(Value, 10);

    end else if SameText(Key, CNT_SAVE_FSondageLastPlaneteSel) then begin
       FSondageLastPlaneteSel := StrToIntDef(Value, 0);

    end else if SameText(Key, CNT_SAVE_FAttackLastPlanete) then begin
       FAttackLastPlaneteSel := StrToIntDef(Value, 0);


    end else if SameText(Key, CNT_SAVE_FSondageDureeToBeConsideredAsRecent) then begin
       FSondageDureeToBeConsideredAsRecent := StrToIntDef(Value, 259200);

    end else if SameText(Key, CNT_SAVE_FSondageDureeToDontBeSondeANouveau) then begin
       FSondageDureeToDontBeSondeANouveau := StrToIntDef(Value, 36000);

    end;



end;

procedure TProfilsAttack.LoadAlerteAttaqueLigne(Key, Value: string);
begin


    if SameText(Key, CNT_SAVE_AlerteAttBeepActive) then begin
       AlerteAttBeepActive := Value = '1';

    end else if SameText(Key, CNT_SAVE_AlerteAttBeepQuantite) then begin
       AlerteAttBeepQuantite := StrToIntDef(Value, 1);

    end else if SameText(Key, CNT_SAVE_AlerteAttBeepIntervalle) then begin
       AlerteAttBeepIntervalle := StrToIntDef(Value, 5);

    end else if SameText(Key, CNT_SAVE_AlerteAttBeepUntilImpact) then begin
       AlerteAttBeepUntilImpact := Value = '1';

    end else if SameText(Key, CNT_SAVE_AlerteAttBeepFreq) then begin
       AlerteAttBeepFreq := StrToIntDef(Value, 440);

    end else if SameText(Key, CNT_SAVE_AlerteAttBeepDuree) then begin
       AlerteAttBeepDuree := StrToIntDef(Value, 100);




    end else if SameText(Key, CNT_SAVE_AlerteAttMusiqueActive) then begin
       AlerteAttMusiqueActive := Value = '1';

    end else if SameText(Key, CNT_SAVE_AlerteAttMusiqueQuantite) then begin
       AlerteAttMusiqueQuantite := StrToIntDef(Value, 1);

    end else if SameText(Key, CNT_SAVE_AlerteAttMusiqueIntervalle) then begin
       AlerteAttMusiqueIntervalle := StrToIntDef(Value, 5);

    end else if SameText(Key, CNT_SAVE_AlerteAttMusiqueUntilImpact) then begin
       AlerteAttMusiqueUntilImpact := Value = '1';

    end else if SameText(Key, CNT_SAVE_AlerteAttMusiqueFichier) then begin
       AlerteAttMusiqueFichier := trim(Value);



    end else if SameText(Key, CNT_SAVE_AlerteAttProgExtActive) then begin
       AlerteAttProgExtActive := Value = '1';

    end else if SameText(Key, CNT_SAVE_AlerteAttProgExtFichier) then begin
       AlerteAttProgExtFichier := trim(Value);

    end else if SameText(Key, CNT_SAVE_AlerteAttProgExtParametres) then begin
       AlerteAttProgExtParametres := trim(Value);



    end else if SameText(Key, CNT_SAVE_AlerteAttVerifEveryMinutes) then begin
       AlerteAttVerifEveryMinutes := StrToIntDef(Value, 20);

    end else if SameText(Key, CNT_SAVE_AlerteAttVerifHumanAdd) then begin
       AlerteAttVerifHumanAdd   := StrToIntDef(Value, 15);



    end else if SameText(Key, CNT_SAVE_AlerteAttVerifEveryMinutesWhenAttacked) then begin
       AlerteAttVerifEveryMinutesWhenAttacked := StrToIntDef(Value, 5);

    end else if SameText(Key, CNT_SAVE_AlerteAttVerifHumanAddWhenAttacked) then begin
       AlerteAttVerifHumanAddWhenAttacked   := StrToIntDef(Value, 10);




    end else if SameText(Key, CNT_SAVE_AlerteAttEnableOnLogin) then begin
       AlerteAttEnableOnLogin := Value = '1';

    end;



end;


procedure TProfilsAttack.LoadProxyLigne(Key, Value: string);
begin

    if SameText(Key, CNT_SAVE_FProxyHostname) then begin
       FProxyHostname := trim(Value);

    end else if SameText(Key, CNT_SAVE_FProxyPort) then begin
       FProxyPort := StrToIntDef(Value, 8080);


    end else if SameText(Key, CNT_SAVE_FProxyActive) then begin
       FProxyActive := Value = '1';

    end else if SameText(Key, CNT_SAVE_FProxyIdentifActive) then begin
       FProxyIdentifActive := Value = '1';


    end else if SameText(Key, CNT_SAVE_FProxyUsername) then begin
       FProxyUsername := trim(Value);

    end else if SameText(Key, CNT_SAVE_FProxyPassword) then begin
       FProxyPassword := trim(Value);

    end else if SameText(Key, CNT_SAVE_FProxyType) then begin
       FProxyType := StrToIntDef(Value, 0);

    end;

end;

procedure TProfilsAttack.LoadEvacuationLigne(Key, Value: string);
begin


     if SameText(Key, CNT_SAVE_EvacuationPourcentagePropreFlotte) then begin
       EvacuationPourcentagePropreFlotte := StrToIntDef(Value, 40);

    end else if SameText(Key, CNT_SAVE_EvacuationPourcentablePropreDefense) then begin
       EvacuationPourcentablePropreDefense := StrToIntDef(Value, 70);


    end else if SameText(Key, CNT_SAVE_EvacuationActive) then begin
       EvacuationActive := Value = '1';
    end else if SameText(Key, CNT_SAVE_EvacuationSeulementSiOnPerdLaBataille) then begin
       EvacuationSeulementSiOnPerdLaBataille := Value = '1';


    end else if SameText(Key, CNT_SAVE_EvacuationDeFlotteDelaiAvantImpact) then begin
       EvacuationDeFlotteDelaiAvantImpact := StrToIntDef(Value, 180);

    end else if SameText(Key, CNT_SAVE_EvacuationDeFlotteDelaiAvantImpactRandom) then begin
       EvacuationDeFlotteDelaiAvantImpactRandom := StrToIntDef(Value, 120);



    end else if SameText(Key, CNT_SAVE_EvacuationDeFlotteRetourDelaiEnable) then begin
       EvacuationDeFlotteRetourDelaiEnable := Value = '1';

    end else if SameText(Key, CNT_SAVE_EvacuationDeFlotteRetourDelai) then begin
       EvacuationDeFlotteRetourDelai := StrToIntDef(Value, 300);

    end else if SameText(Key, CNT_SAVE_EvacuationDeFlotteRetourDelaiRandom) then begin
       EvacuationDeFlotteRetourDelaiRandom := StrToIntDef(Value, 500);
    end;


end;


procedure TProfilsAttack.LoadGeneralLigne(Key, Value: string);
begin


    if SameText(Key, CNT_SAVE_PSEUDO) then begin
       FPseudo := trim(Value);

    end else if SameText(Key, CNT_SAVE_FPassword) then begin
       FPassword := trim(Value);

    end else if SameText(Key, CNT_SAVE_FUnivers) then begin
       FUnivers := StrToIntDef(Value, -1);

    end else if SameText(Key, CNT_SAVE_FLangUni) then begin
       FLangUni := trim(Value);



    end else if SameText(Key, CNT_SAVE_FLimitGlobal) then begin
       FLimitStatsGlobal := StrToIntDef(Value, -1);

    end else if SameText(Key, CNT_SAVE_FLimitFlotte) then begin
       FLimitStatsFlotte := StrToIntDef(Value, -1);


    end else if SameText(Key, CNT_SAVE_FLimitQtDefense) then begin
       FLimitQtDefense := StrToIntDef(Value, -1);

    end else if SameText(Key, CNT_SAVE_FLimitQtFlotte) then begin
       FLimitQtFlotte := StrToIntDef(Value, -1);

    end else if SameText(Key, CNT_SAVE_LastGalaxieLoaded) then begin
       FLastRapportGalaxieUsed := StrToIntDef(Value, -1);





    end else if SameText(Key, CNT_SAVE_FAgent) then begin
       FAgent := trim(Value);

    end else if SameText(Key, CNT_SAVE_FAcceptLanguage) then begin
       FAcceptLanguage := trim(Value);
    end else if SameText(Key, CNT_SAVE_FAccept) then begin
       FAccept := trim(Value);

    end else if SameText(Key, CNT_SAVE_FGZipEncoding) then begin
       FGZipEncoding := Value = '1';




    end else if SameText(Key, CNT_SAVE_MessageListSauvegardeRapportDeCombat) then begin
       MessageListSauvegardeRapportDeCombat := Value = '1';


    end else if SameText(Key, CNT_SAVE_CapaciteFretCalculMethodUseContrainte) then begin
       CapaciteFretCalculMethodUseContrainte := Value = '1';



    end else if SameText(Key, CNT_SAVE_UniversDefenseRecyclable) then begin
       UniversDefenseRecyclable := Value = '1';

    end else if SameText(Key, CNT_SAVE_UniversDefenseRecyclPourcent) then begin
       UniversDefenseRecyclPourcent := StrToIntDef(Value, 30);

    end else if SameText(Key, CNT_SAVE_UniversSpeedFactorElements) then begin
       UniversSpeedFactorElements := StrToIntDef(Value, 1);

    end else if SameText(Key, CNT_SAVE_UniversSpeedFactorFlotte) then begin
       UniversSpeedFactorFlotte := StrToIntDef(Value, 1);


    end else if SameText(Key, CNT_SAVE_UniversNbGalaxy) then begin
       UniversNbGalaxy := StrToIntDef(Value, 9);

    end else if SameText(Key, CNT_SAVE_UniversNbSystemSolaireParGalaxy) then begin
       UniversNbSystemSolaireParGalaxy := StrToIntDef(Value, 499);



    end else if SameText(Key, CNT_SAVE_OGSServeurURL) then begin
       OGSServeurURL := trim(Value);
    end else if SameText(Key, CNT_SAVE_OGSUsername) then begin
       OGSUsername := trim(Value);
    end else if SameText(Key, CNT_SAVE_OGSPassword) then begin
       OGSPassword := Value;

    end else if SameText(Key, CNT_SAVE_OGSExportQuantityCartographie) then begin
       OGSExportQuantityCartographie := StrToIntDef(Value, 250);
    end else if SameText(Key, CNT_SAVE_OGSExportQuantityRapports) then begin
       OGSExportQuantityRapports     := StrToIntDef(Value, 50);
    end else if SameText(Key, CNT_SAVE_OGSExportDuration) then begin
       OGSExportDuration := StrToIntDef(Value, 3600 * 24 * 7);



       


    end else if SameText(Key, CNT_SAVE_HumanGalaxieScanEnable) then begin
       HumanGalaxieScanEnable := Value = '1';
    end else if SameText(Key, CNT_SAVE_HumanGalaxieScanDuree) then begin
       HumanGalaxieScanDuree := StrToIntDef(Value, 1);
    end else if SameText(Key, CNT_SAVE_HumanGalaxieScanAleatoire) then begin
       HumanGalaxieScanAleatoire := StrToIntDef(Value, 4);




    end else if SameText(Key, CNT_SAVE_FNewbzLevelMineMetal) then begin
       FNewbzLevelMineMetal := StrToIntDef(Value, 8);

    end else if SameText(Key, CNT_SAVE_FNewbzLevelMineCristal) then begin
       FNewbzLevelMineCristal := StrToIntDef(Value, 8);

    end else if SameText(Key, CNT_SAVE_FNewbzLevelMineBoth) then begin
       FNewbzLevelMineBoth := StrToIntDef(Value, 20);

    end else if SameText(Key, CNT_SAVE_FNewbzDelaisIngoreSondage) then begin
       FNewbzDelaisIngoreSondage := StrToIntDef(Value, 3600 * 24 * 7);

    end else if SameText(Key, CNT_SAVE_FNewbzSetFlagPeuDevAuto) then begin
       FNewbzSetFlagPeuDevAuto := StrToIntDef(Value, 0);


    end else if SameText(Key, CNT_SAVE_FVersionPT) then begin
       FVersionPT := Value = '1';




    end else if SameText(Key, CNT_SAVE_FSondesNbMini) then begin
       FSondesNbMini   := StrToIntDef(Value, 1);
    end else if SameText(Key, CNT_SAVE_FSondesNbNivEsp) then begin
       FSondesNbNivEsp := StrToIntDef(Value, 4);




    end else if SameText(Key, CNT_SAVE_AutoReloginEnable) then begin
       AutoReloginEnable := Value = '1';

    end else if SameText(Key, CNT_SAVE_AutoReloginDelay) then begin
       AutoReloginDelay := StrToIntDef(Value, 60);

    end else if SameText(Key, CNT_SAVE_AutoReloginMinInterval) then begin
       AutoReloginMinInterval := StrToIntDef(Value, 240);






    end else if SameText(Key, CNT_SAVE_FiltrePresenceTousDefaut) then begin
       FiltrePresenceTousDefaut := Value = '1';

    end else if SameText(Key, CNT_SAVE_FiltreFlagsAucunRapportInclu) then begin
       FiltreFlagsAucunRapportInclu := Value = '1';

    end else if SameText(Key, CNT_SAVE_FiltreFlagsRapportInclu) then begin
       FiltreFlagsRapportInclu := StrToIntDef(Value, 0);

    end else if SameText(Key, CNT_SAVE_FiltreFlagsRapportExclu) then begin
       FiltreFlagsRapportExclu := StrToIntDef(Value, 0);

    end else if SameText(Key, CNT_SAVE_FiltreFlagsGalaxieInclu) then begin
       FiltreFlagsGalaxieInclu := StrToIntDef(Value, 0);

    end else if SameText(Key, CNT_SAVE_FiltreFlagsGalaxieExclu) then begin
       FiltreFlagsGalaxieExclu := StrToIntDef(Value, 0);

    end else if SameText(Key, CNT_SAVE_FiltreInclusionMethodAllVerif) then begin
       FiltreInclusionMethodAllVerif := Value = '1';

    end;



end;


procedure TProfilsAttack.LoadAllianceFromLigne(Key, Value: string);
var i: integer;
begin

    Value := trim(Value);

    if Value <> '' then
       FAlliancesAlliees.Add(Value);

end;

procedure TProfilsAttack.LoadPlaneteFromLigne(Key, Value: string);
begin
    Value := trim(Value);

    if Value <> '' then
       FPlanetesList.Add(Value);

end;

procedure TProfilsAttack.LoadGalaxiesFromLigne(Key, Value: string);
var i: integer;
begin

    Key := trim(Key);
    if Key = '' then exit;
    if Key[1] <> 'g' then exit;

    System.Delete(Key, 1, 1);

    i := StrToIntDef(Key, -1);

    if i < 1 then exit;
    if i > 500 then exit;

    Value := trim(Value);
    if Value = '' then exit;

    SetRapportDB(i, Value);
end;


function TProfilsAttack.LoadFromFile(Fichier: string): integer;
type TFileSectionWhere = (typfwGeneral,
                          typfwAlliances,
                          typfwGalaxiesDB,
                          typfwPlanetes,
                          typfwSondage,
                          typfwEvacuation,
                          typfwProxy,
                          typfwAlertAtt,
                          typfwUnknow);
label lErreur;
var F: TextFile;
    xPos: integer;
    Ligne, Key, Value : string;

    CurrSection: TFileSectionWhere;
begin

    InitProfil;

    FFichier := Fichier;

    AssignFile(F, Fichier);


    {$I-}
      ReSet(F);
    {$I+}

    // IOResult renvoie 0 => cela signifie que la dernière opération d'E/S a réussi
    if NoT(IOResult = 0) then begin
       Result := -1;
       exit;
    end;

    Result := 0;
    CurrSection := typfwGeneral;



    While NoT(EoF(F)) do begin
         // Lit une ligne
         ReadLn(F, Ligne);

         Ligne := trim(Ligne);
         if Ligne = '' then Continue;


         xPos := pos('=', Ligne);

         if xPos = 0 then begin
            xPos := pos('[', Ligne);

            if xPos > 0 then begin
               Key := copy(Ligne, xPos + 1, maxint);

               xPos := pos(']', Key);
               if xPos > 0 then begin
                  System.Delete(Key, xPos, maxint);

                  Key := trim(Key);


                  if SameText(CNT_SECTION_PRINCIPALE, Key) then begin
                     CurrSection := typfwGeneral;

                  end else if SameText(CNT_SECTION_ALLIANCES, Key) then begin
                     CurrSection := typfwAlliances;

                  end else if SameText(CNT_SECTION_GALAXIESDB, Key) then begin
                     CurrSection := typfwGalaxiesDB;


                  end else if SameText(CNT_SECTION_PLANETES, Key) then begin
                     CurrSection := typfwPlanetes;

                  end else if SameText(CNT_SECTION_ALERTE_ATTAQUE, Key) then begin
                     CurrSection := typfwAlertAtt;


                  end else if SameText(CNT_SECTION_PROXY, Key) then begin
                     CurrSection := typfwProxy;

                  end else if SameText(CNT_SECTION_SONDAGE, Key) then begin
                     CurrSection := typfwSondage;

                  end else if SameText(CNT_SECTION_EVACUATION, Key) then begin
                     CurrSection := typfwEvacuation;


                  end else begin
                     // section inconnue
                     CurrSection := typfwUnknow;
                  end;

               end;
            end;

            
         end else begin
             Key := copy(Ligne, 1, xPos - 1);
             Value := copy(Ligne, xPos + 1, maxint);

             case CurrSection of
                  typfwGeneral   : LoadGeneralLigne(Key, Value);
                  typfwAlliances : LoadAllianceFromLigne(Key, Value);
                  typfwGalaxiesDB: LoadGalaxiesFromLigne(Key, Value);
                  typfwPlanetes  : LoadPlaneteFromLigne(Key, Value);
                  typfwSondage   : LoadSondageLigne(Key, Value);
                  typfwProxy     : LoadProxyLigne(Key, Value);
                  typfwAlertAtt  : LoadAlerteAttaqueLigne(Key, Value);
                  typfwEvacuation: LoadEvacuationLigne(Key, Value);
             end;
         end;


    end;


    // Ferme le fichier
    CloseFile(F);


    if IsValidProfil then begin
       Result := 1;
    end;

end;


procedure TProfilsAttack.SetDefaultValue;
begin
      // Limites de points
      FLimitStatsGlobal := 8000;
      FLimitStatsFlotte := 100;

      FLimitQtDefense:= 15;
      FLimitQtFlotte := 30;

      // Liste de chaines
      FAlliancesAlliees.Clear;
      FFichierRapportDB.Clear;
end;


procedure TProfilsAttack.InitProfil;
begin
      // Pseudo du joueur
      FPseudo := '';

      // Univers
      FUnivers := -1;

      // Limites de points
      FLimitStatsGlobal := -1;
      FLimitStatsFlotte := -1;

      FLimitQtDefense:= -1;
      FLimitQtFlotte := -1;

      FLastRapportGalaxieUsed := -1;

      // Liste de chaines
      FAlliancesAlliees.Clear;
      FFichierRapportDB.Clear;
      FPlanetesList.Clear;

      // SURTOUT le chemin du fichier doit être réinitialisé
      FFichier := '';

      // Limites de points pour le sondage
      FSondageLimitStatsGlobal                  := 5000;
      FSondageLimitStatsGlobalInclureNonClasse  := true;

      FSondageLimitStatsFlottes                 := 150;
      FSondageLimitStatsFlottesInclureNonClasse := true;

      // Autre informations pour le sondage
      FSondageSystemRangeStart  := 1;
      FSondageSystemRangeEnd    := 10;
      FSondageLastPlaneteSel    := 0;  // l'index dans la combobox
      FAttackLastPlaneteSel     := 0;  // l'index dans la combobox

      FSondageDureeToBeConsideredAsRecent:= 3600 * 24 * 3;  // ce n'est qu'une durée, int64 est inutile

      FNewbzLevelMineMetal      :=  8;
      FNewbzLevelMineCristal    :=  8;
      FNewbzLevelMineBoth       := 20;
      FNewbzDelaisIngoreSondage := 3600 * 24 * 7;
      FNewbzSetFlagPeuDevAuto   :=  0;



      // Pour les éléments filtrée (et sauvegardé le filtre)
      FiltrePresenceTousDefaut     := false;
      FiltreFlagsAucunRapportInclu := false;  // si False, alors Exclu (il n'y a pas de 'sans importance')
      FiltreFlagsRapportInclu      := 0;

      FiltreLuneState              := CNT_FILTRE_LNE_STATE_EXCLURE;

      // Une planète peut avoir plusieurs flags, on peut exclure (interdire) des flags
      // même si la planète correspond à d'autre flag "inclu"
      FiltreFlagsRapportExclu      := 0;

      FiltreFlagsGalaxieInclu      := 0;
      FiltreFlagsGalaxieExclu      := 0;

      FAgent := 'Mozilla/5.0 (Windows; U; Windows NT 5.1; fr-FR; rv:1.9.1.7) Gecko/20100106 Firefox/3.5.7';
      FAcceptLanguage := 'en-us,en;q=0.5';
      FAccept         := 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5';

      FLangUni := LANG_INTERNAL;

      FDirectLogin    := false;
      FDirectLoginURL := '';


      FProxyUsername:= '';
      FProxyPassword:= '';
      FProxyType    := 0;
      FProxyActive  := false;


      FSondesNbMini   := 1;
      FSondesNbNivEsp := 4;



      ///////////////////////////
      // Alerte d'attaque

      // beep
      AlerteAttBeepActive      := false;
      AlerteAttBeepQuantite    := -1;
      AlerteAttBeepIntervalle  := 5;
      AlerteAttBeepUntilImpact := true;

      AlerteAttBeepFreq  := 440;
      AlerteAttBeepDuree := 100;


      // musique
      AlerteAttMusiqueActive     := false;
      AlerteAttMusiqueQuantite   := -1;
      AlerteAttMusiqueIntervalle := 60;
      AlerteAttMusiqueUntilImpact:= true;
      AlerteAttMusiqueFichier    := '';

      // programme externe
      AlerteAttProgExtActive    := false;
      AlerteAttProgExtFichier   := '';
      AlerteAttProgExtParametres:= '';


      // fréquence de vérification d'attaque
      AlerteAttVerifEveryMinutes:= 20;
      AlerteAttVerifHumanAdd    := 25;

      AlerteAttVerifEveryMinutesWhenAttacked:= 5;
      AlerteAttVerifHumanAddWhenAttacked    := 9;

      // configuration
      AlerteAttEnableOnLogin    := false;

      //
      ////////////////////////////////////////////////////


      //
      // Alerte d'attaque
      //

      // Active l'auto relogin
      AutoReloginEnable     := false;

      // délai d'attente pour se relogger lorsque l'on détecte l'expiration de session
      AutoReloginDelay       := 35;
      AutoReloginDelayAjoutRandom := 25;

      // intervalle minimal entre chaque auto relogin
      AutoReloginMinInterval := 240;



      MessageListSauvegardeRapportDeCombat := false;



      EvacuationActive  := false;
      EvacuationSeulementSiOnPerdLaBataille := true;


      // On evacue la flotte X secondes avant l'impact
      EvacuationDeFlotteDelaiAvantImpact := 180;
      EvacuationDeFlotteDelaiAvantImpactRandom:= 120;

        // Combien de temps après l'évacuation on fait revenir la flotte ?
        // Mettre à 0 pour desactiver
        EvacuationDeFlotteRetourDelaiEnable := true;
        EvacuationDeFlotteRetourDelai      := 400;
        EvacuationDeFlotteRetourDelaiRandom:= 700;

      EvacuationPourcentagePropreFlotte  := 40;
      EvacuationPourcentablePropreDefense:= 70;



      CapaciteFretCalculMethodUseContrainte := false;


      //
      // Univers spéciaux
      //

       UniversDefenseRecyclable     := false;
       UniversDefenseRecyclPourcent := 30;

       UniversSpeedFactorElements := 1;
       UniversSpeedFactorFlotte   := 1;

       UniversNbGalaxy := 9;
       UniversNbSystemSolaireParGalaxy := 499;


       //
       // OGS
       //

      OGSServeurURL := 'http://url/';
      OGSUsername   := '';
      OGSPassword   := '';
      OGSExportQuantityCartographie:= 250;
      OGSExportQuantityRapports    := 50;
      OGSExportDuration            := 3600 * 24 * 7;

end;


constructor TProfilsAttack.Create;
begin
    inherited Create;

    FFichierRapportDB := TStringList.Create;
    FAlliancesAlliees := TStringList.Create;
    FPlanetesList     := TStringList.Create;

    InitProfil;

    GrilleDesactiveColonneDef := true;

end;

destructor TProfilsAttack.Destroy;
begin
   FAlliancesAlliees.Free;
   FFichierRapportDB.Free;
   FPlanetesList.Free;

   inherited Destroy;
end;


procedure TProfilsAttack.SetRapportDB(Galaxie: integer; Fichier: string);
begin
    Dec(Galaxie);

    while Galaxie >= FFichierRapportDB.Count do begin
       FFichierRapportDB.Add('');
    end;

    FFichierRapportDB.Strings[Galaxie] := Fichier;
end;

function TProfilsAttack.GetRapportDB(Galaxie: integer): string;
begin
    Dec(Galaxie);

    if Galaxie >= FFichierRapportDB.Count then begin
       Result := '';
       exit;
    end;

    Result := FFichierRapportDB.Strings[Galaxie];
end;



end.
